home *** CD-ROM | disk | FTP | other *** search
/ Delphi Developer's Kit 1996 / Delphi Developer's Kit 1996.iso / power / wfc007.000 / src / namdpipe.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1995-12-22  |  9.7 KB  |  400 lines
  1. #include <wfc.h>
  2.  
  3. CNamedPipe::CNamedPipe( DWORD _input_buffer_size, DWORD _output_buffer_size )
  4. {
  5.    m_Initialize( _input_buffer_size, _output_buffer_size );
  6. }
  7.  
  8. CNamedPipe::~CNamedPipe()
  9. {
  10.    if ( m_AutomaticallyDelete == TRUE )
  11.    {
  12.       if ( m_PipeHandle != (HANDLE) NULL )
  13.       {
  14.          Close();
  15.       }
  16.    }
  17.  
  18.    if ( m_InputBuffer != (LPVOID) NULL )
  19.    {
  20.       /*
  21.       ** Free our memory
  22.       */
  23.  
  24.       delete [] m_InputBuffer;
  25.  
  26.       m_InputBuffer = (LPVOID) NULL;
  27.       m_InputBufferSize = 0L;
  28.    }
  29.  
  30.    if ( m_OutputBuffer != (LPVOID) NULL )
  31.    {
  32.       /*
  33.       ** Free our memory
  34.       */
  35.  
  36.       delete [] m_OutputBuffer;
  37.  
  38.       m_OutputBuffer = (LPVOID) NULL;
  39.       m_OutputBufferSize = 0L;
  40.    }
  41. }
  42.  
  43. void CNamedPipe::m_Initialize( DWORD _input_buffer_size, DWORD _output_buffer_size )
  44. {
  45.    m_AutomaticallyDelete = TRUE;
  46.    m_ErrorCode  = 0L;
  47.    m_PipeHandle = INVALID_HANDLE_VALUE;
  48.    m_Timeout    = NMPWAIT_USE_DEFAULT_WAIT;
  49.    m_PipeName.Empty();
  50.  
  51.    m_InputBufferSize  = _input_buffer_size;
  52.    m_OutputBufferSize = _output_buffer_size;
  53.  
  54.    m_InputBuffer  = new BYTE[ m_InputBufferSize  ];
  55.    m_OutputBuffer = new BYTE[ m_OutputBufferSize ];
  56. }
  57.  
  58. BOOL CNamedPipe::Call( CString& pipe_name, 
  59.                        LPVOID   write_buffer, 
  60.                        DWORD    size_of_write_buffer, 
  61.                        LPVOID   read_buffer, 
  62.                        DWORD    size_of_read_buffer, 
  63.                        DWORD   *address_of_number_of_bytes_read,
  64.                        DWORD    number_of_milliseconds_to_wait )
  65. {
  66.    ASSERT( write_buffer != NULL );
  67.    ASSERT( read_buffer  != NULL );
  68.  
  69.    if ( write_buffer == NULL || read_buffer == NULL )
  70.    {
  71.       m_ErrorCode = ERROR_INVALID_PARAMETER;
  72.       return( FALSE );
  73.    }
  74.  
  75.    /*
  76.    ** Writes to the pipe then reads from it
  77.    */
  78.  
  79.    BOOL return_value;
  80.  
  81.    return_value = ::CallNamedPipe( pipe_name, 
  82.                                    write_buffer,
  83.                                    size_of_write_buffer,
  84.                                    read_buffer,
  85.                                    size_of_read_buffer,
  86.                                    address_of_number_of_bytes_read,
  87.                                    number_of_milliseconds_to_wait );
  88.  
  89.    if ( return_value == TRUE )
  90.    {
  91.       return( TRUE );
  92.    }
  93.    else
  94.    {
  95.       m_ErrorCode = ::GetLastError();
  96.  
  97.       return( FALSE );
  98.    }
  99. }
  100.  
  101. void CNamedPipe::Close( void )
  102. {
  103.    if ( m_PipeHandle != INVALID_HANDLE_VALUE )
  104.    {
  105.       ::CloseHandle( m_PipeHandle );
  106.       m_PipeHandle = INVALID_HANDLE_VALUE;
  107.    }
  108. }
  109.  
  110. BOOL CNamedPipe::Connect( LPOVERLAPPED overlapped_p )
  111. {
  112.    // overlapped_p can be NULL
  113.  
  114.    BOOL return_value;
  115.  
  116.    return_value = ::ConnectNamedPipe( m_PipeHandle, overlapped_p );
  117.  
  118.    if ( return_value == TRUE )
  119.    {
  120.       return( TRUE );
  121.    }
  122.    else
  123.    {
  124.       m_ErrorCode = ::GetLastError();
  125.  
  126.       return( FALSE );
  127.    }
  128. }
  129.  
  130. BOOL CNamedPipe::Create( LPCTSTR server_name,
  131.                          LPCTSTR pipe_name,
  132.                          DWORD   open_mode,
  133.                          DWORD   type_of_pipe,
  134.                          DWORD   number_of_pipes,
  135.            LPSECURITY_ATTRIBUTES security_attributes_p )
  136. {
  137.    ASSERT( pipe_name != NULL );
  138.  
  139.    /*
  140.    ** Check parameters for errors
  141.    */
  142.  
  143.    if ( pipe_name == NULL )
  144.    {
  145.       m_ErrorCode = ERROR_INVALID_PARAMETER;
  146.       return( FALSE );
  147.    }
  148.  
  149.    m_PipeName = "\\\\";
  150.  
  151.    if ( server_name == NULL )
  152.    {
  153.       m_PipeName += ".";
  154.    }
  155.    else
  156.    {
  157.       m_PipeName += server_name;
  158.    }
  159.  
  160.    m_PipeName += "\\pipe\\";
  161.    m_PipeName += pipe_name;
  162.  
  163.    CSecurityAttributes security_attributes;
  164.    SECURITY_DESCRIPTOR security_descriptor;
  165.  
  166.    if ( security_attributes_p == NULL )
  167.    {
  168.       ::InitializeSecurityDescriptor( &security_descriptor, SECURITY_DESCRIPTOR_REVISION );
  169.  
  170.       ::SetSecurityDescriptorDacl( &security_descriptor, TRUE, NULL, FALSE );
  171.       security_attributes.bInheritHandle = FALSE;
  172.       security_attributes.lpSecurityDescriptor = &security_descriptor;
  173.  
  174.       security_attributes_p = (SECURITY_ATTRIBUTES *) &security_attributes;
  175.    }
  176.  
  177.    m_PipeHandle = ::CreateNamedPipe( m_PipeName,
  178.                                      open_mode,
  179.                                      type_of_pipe, 
  180.                                      number_of_pipes,
  181.                                      m_OutputBufferSize,
  182.                                      m_InputBufferSize,
  183.                                      m_Timeout,
  184.                                      security_attributes_p );
  185.  
  186.    if ( m_PipeHandle == INVALID_HANDLE_VALUE )
  187.    {
  188.       m_ErrorCode = ::GetLastError();
  189.       return( FALSE );
  190.    }
  191.    else
  192.    {
  193.       return( TRUE );
  194.    }
  195. }
  196.  
  197. BOOL CNamedPipe::Disconnect( void )
  198. {
  199.    BOOL return_value;
  200.  
  201.    return_value = ::DisconnectNamedPipe( m_PipeHandle );
  202.  
  203.    if ( return_value == TRUE )
  204.    {
  205.       return( TRUE );
  206.    }
  207.    else
  208.    {
  209.       m_ErrorCode = ::GetLastError();
  210.  
  211.       return( FALSE );
  212.    }
  213. }
  214.  
  215. DWORD CNamedPipe::GetErrorCode( void ) const
  216. {
  217.    return( m_ErrorCode );
  218. }
  219.  
  220. BOOL CNamedPipe::GetInformation( void )
  221. {
  222.    BOOL return_value;
  223.  
  224.    DWORD type_of_pipe                = 0;
  225.    DWORD size_of_output_buffer       = 0;
  226.    DWORD size_of_input_buffer        = 0;
  227.    DWORD maximum_number_of_instances = 0;
  228.  
  229.    return_value = ::GetNamedPipeInfo( m_PipeHandle,
  230.                                      &type_of_pipe,
  231.                                      &size_of_output_buffer,
  232.                                      &size_of_input_buffer,
  233.                                      &maximum_number_of_instances );
  234.  
  235.    if ( return_value == TRUE )
  236.    {
  237.       return( TRUE );
  238.    }
  239.    else
  240.    {
  241.       m_ErrorCode = ::GetLastError();
  242.  
  243.       return( FALSE );
  244.    }
  245. }
  246.  
  247. BOOL CNamedPipe::GetState( void )
  248. {
  249.    BOOL return_value;
  250.  
  251.    TCHAR temp_string[ 513 ];
  252.  
  253.    ::ZeroMemory( temp_string, sizeof( temp_string ) );
  254.  
  255.    return_value = ::GetNamedPipeHandleState( m_PipeHandle,
  256.                                             &m_PipeState,
  257.                                             &m_NumberOfInstances,
  258.                                             &m_MaximumNumberOfBytesBeforeRemoteTransmission,
  259.                                             &m_MaximumNumberOfMillisecondsBeforeRemoteTransmission,
  260.                                              temp_string,
  261.                                              sizeof( temp_string ) );
  262.  
  263.    m_UserNameOfClientProcess = temp_string;
  264.  
  265.    if ( return_value == TRUE )
  266.    {
  267.       return( TRUE );
  268.    }
  269.    else
  270.    {
  271.       m_ErrorCode = ::GetLastError();
  272.  
  273.       return( FALSE );
  274.    }
  275. }
  276.  
  277. BOOL CNamedPipe::Peek( LPVOID buffer_address, 
  278.                        DWORD  size_of_buffer,
  279.                        DWORD& number_of_bytes_read,
  280.                        DWORD& number_of_bytes_available,
  281.                        DWORD& number_of_bytes_remaining_in_message )
  282. {
  283.    /*
  284.    ** buffer_address can be NULL
  285.    */
  286.  
  287.    BOOL return_value;
  288.  
  289.    return_value = ::PeekNamedPipe( m_PipeHandle, 
  290.                                    buffer_address, 
  291.                                    size_of_buffer, 
  292.                                   &number_of_bytes_read,
  293.                                   &number_of_bytes_available,
  294.                                   &number_of_bytes_remaining_in_message );
  295.  
  296.    if ( return_value == TRUE )
  297.    {
  298.       return( TRUE );
  299.    }
  300.    else
  301.    {
  302.       m_ErrorCode = ::GetLastError();
  303.  
  304.       return( FALSE );
  305.    }
  306. }
  307.  
  308. BOOL CNamedPipe::SetState( DWORD new_pipe_mode, 
  309.                            DWORD maximum_number_of_bytes_before_transmission, 
  310.                            DWORD maximum_number_of_milliseconds_before_transmission )
  311. {
  312.    BOOL return_value;
  313.  
  314.    return_value = ::SetNamedPipeHandleState( m_PipeHandle,
  315.                                             &new_pipe_mode,
  316.                                             &maximum_number_of_bytes_before_transmission,
  317.                                             &maximum_number_of_milliseconds_before_transmission );
  318.  
  319.    if ( return_value == TRUE )
  320.    {
  321.       return( TRUE );
  322.    }
  323.    else
  324.    {
  325.       m_ErrorCode = ::GetLastError();
  326.  
  327.       return( FALSE );
  328.    }
  329. }
  330.  
  331. BOOL CNamedPipe::Transact( LPOVERLAPPED overlapped_p )
  332. {
  333.    // overlapped_p can be NULL
  334.  
  335.    BOOL return_value;
  336.  
  337.    return_value = ::TransactNamedPipe( m_PipeHandle,
  338.                                        m_OutputBuffer,
  339.                                        m_NumberOfBytesToWrite,
  340.                                        m_InputBuffer,
  341.                                        m_InputBufferSize,
  342.                                       &m_NumberOfBytesRead,
  343.                                        overlapped_p );
  344.  
  345.    if ( return_value == TRUE )
  346.    {
  347.       return( TRUE );
  348.    }
  349.    else
  350.    {
  351.       m_ErrorCode = ::GetLastError();
  352.  
  353.       return( FALSE );
  354.    }
  355. }
  356.  
  357. BOOL CNamedPipe::Wait( LPCTSTR name_of_server ,LPCTSTR name_of_pipe, DWORD number_of_milliseconds )
  358. {
  359.    ASSERT( name_of_pipe != NULL );
  360.  
  361.    /*
  362.    ** Check parameters for errors
  363.    */
  364.  
  365.    if ( name_of_pipe == NULL )
  366.    {
  367.       m_ErrorCode = ERROR_INVALID_PARAMETER;
  368.       return( FALSE );
  369.    }
  370.  
  371.    BOOL return_value;
  372.  
  373.    CString full_pipe_name( "\\\\" ); // like \\servername\pipe\pipename
  374.  
  375.    if ( name_of_server == NULL )
  376.    {
  377.       full_pipe_name += ".";
  378.    }
  379.    else
  380.    {
  381.       full_pipe_name += name_of_server;
  382.    }
  383.  
  384.    full_pipe_name += "\\pipe\\";
  385.    full_pipe_name += name_of_pipe;
  386.  
  387.    return_value = ::WaitNamedPipe( full_pipe_name, number_of_milliseconds );
  388.  
  389.    if ( return_value == TRUE )
  390.    {
  391.       return( TRUE );
  392.    }
  393.    else
  394.    {
  395.       m_ErrorCode = ::GetLastError();
  396.  
  397.       return( FALSE );
  398.    }
  399. }
  400.